package com.ocom.common.utils;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import lombok.extern.slf4j.Slf4j;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.TimeZone;

/**
 * JSON 序列化与反序列化工具类（基于 Jackson）
 */
@Slf4j
public class JsonUtils {
    private static final ObjectMapper objectMapper = new ObjectMapper();

    static {
        // 基础配置
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL); // 忽略 null 字段
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); // 忽略未知字段
        objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false); // 禁用时间戳格式

        // 日期格式化（UTC 时间）
        objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
        objectMapper.setTimeZone(TimeZone.getTimeZone("UTC"));

        // 支持 Java 8 时间类型（LocalDate/LocalDateTime）
        objectMapper.registerModule(new JavaTimeModule());
    }

    /**
     * 对象序列化为 JSON 字符串
     */
    public static String toJson(Object obj) {
        try {
            return objectMapper.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            log.info("序列化失败 【{}】【{}】" ,obj,e);
            return null;
        }
    }

    /**
     * JSON 字符串反序列化为对象（普通类型）
     */
    public static <T> T fromJson(String json, Class<T> clazz) {
        try {
            return objectMapper.readValue(json, clazz);
        } catch (IOException e) {
            log.info("反序列化失败 【{}】【{}】" ,json, e);
            return null;
        }
    }

    /**
     * JSON 字符串反序列化为对象（普通类型）
     */
    public static <T> T fromJson(Object json, Class<T> clazz) {
        if(json == null )  return null;
        try {
            return objectMapper.readValue((String)json, clazz);
        } catch (IOException e) {
            log.info("反序列化失败 【{}】【{}】" ,json, e);
            return null;
        }
    }

    /**
     * JSON 字符串反序列化为对象（支持泛型，如 List<T>/Map<K,V>）
     * 示例：List<User> list = JsonUtils.fromJson(json, new TypeReference<List<User>>() {});
     */
    public static <T> T fromJson(String json, TypeReference<T> typeReference) {
        if(json == null )  return null;
        try {
            return objectMapper.readValue(json, typeReference);
        } catch (IOException e) {
            log.info("反序列化失败 【{}】【{}】" ,json, e);
            return null;
        }
    }

    /**
     * JSON 字符串反序列化为对象（支持泛型，如 List<T>/Map<K,V>）
     * 示例：List<User> list = JsonUtils.fromJson(json, new TypeReference<List<User>>() {});
     */
    public static <T> T fromJson(Object json, TypeReference<T> typeReference) {
        if(json == null )  return null;
        try {
            return objectMapper.readValue((String)json, typeReference);
        } catch (IOException e) {
            log.info("反序列化失败 【{}】【{}】" ,json, e);
            return null;
        }
    }

    // 禁止实例化
    private JsonUtils() {}


    /**
     * 使用示例
     * 1. 序列化对象
     * java
     * 复制
     * User user = new User("123", "John", 30);
     * String json = JsonUtils.toJson(user);
     * // 输出: {"id":"123","name":"John","age":30}
     * 2. 反序列化普通对象
     * java
     * 复制
     * String json = "{\"id\":\"123\",\"name\":\"John\",\"age\":30}";
     * User user = JsonUtils.fromJson(json, User.class);
     * 3. 反序列化泛型集合
     * java
     * 复制
     * String json = "[{\"id\":\"1\",\"name\":\"John\"}, {\"id\":\"2\",\"name\":\"Alice\"}]";
     * List<User> users = JsonUtils.fromJson(json, new TypeReference<List<User>>() {});
     */


}
